package lottery

import (
	"context"
	"encoding/json"
	"fmt"
	"math/rand"
	"sale-admin/config"
	"sale-admin/config/mysql"
	"sale-admin/config/redis"
	"sale-admin/internal/app/web/service/common"
	"sale-admin/internal/dal"
	"sale-admin/internal/dao"
	"sale-admin/internal/define"
	"sale-admin/internal/models"
	"strconv"
	"strings"
	"time"

	"192.168.1.75/go-pkg/errorx"
	"192.168.1.75/go-pkg/helper"
	"192.168.1.75/go-pkg/logx"
	"github.com/golang-module/carbon"
	"gorm.io/gorm"
)

type LotteryMemberService struct{}

// 包含会员抽奖、中奖信息
type MyMemberInfo struct {
	models.MaLotteryMember
	// 抽奖次数
	LotteryTimes int `gorm:"column:lottery_times;type:int" json:"lottery_times"`
	// 中奖次数
	WinTimes int `gorm:"column:win_times;type:int" json:"win_times"`
}

// List 会员列表
func (ls LotteryMemberService) List(ctx context.Context, merchantID string,
	Page, Limit int,
	Name string,
	ProvinceID string,
	CityID string,
	Phone string,
	Status int,
	StartCreatedAt,
	EndCreatedAt,
	StartUpdatedAt,
	EndUpdatedAt int,
) (
	list []models.MaLotteryMember,
	// list []MyMemberInfo,
	count int64,
	err error,
) {
	db := mysql.NewDB()
	tx := db.Model(&models.MaLotteryMember{})
	// 有哪些检索的字段？

	// 1. 检索会员名称
	if Name != "" {
		tx.Where("name like ? and deleted_at = 0", "%"+Name+"%")
	}

	// city
	if CityID != "" {
		tx.Where("city_id = ? and deleted_at = 0", CityID)
	}
	// pro
	if ProvinceID != "" {
		tx.Where("province_id = ? and deleted_at = 0", ProvinceID)
	}

	// 检索会员状态
	if Status != 0 {
		tx.Where("status = ? and deleted_at = 0", Status)
	}
	// 检索会员状态
	if Phone != "" {
		tx.Where("phone = ? and deleted_at = 0", Phone)
	}

	// 检索首次参与时间【start - end】
	if StartCreatedAt != 0 && EndCreatedAt != 0 {
		tx.Where("created_at between ? and ?", StartCreatedAt, EndCreatedAt)
	}
	// 检索最近参与时间【start - end】
	if StartUpdatedAt != 0 && EndUpdatedAt != 0 {
		tx.Where("updated_at between ? and ?", StartUpdatedAt, EndUpdatedAt)
	}

	tx.Count(&count)
	// 赋空值
	list = []models.MaLotteryMember{}
	helper.Gorm{}.Paginate(tx, int(Page), int(Limit)).Find(&list)
	return
}

// Detail [单个会员详情]
func (ls LotteryMemberService) Detail(merchantID, ID string) (info models.MaLotteryMember, err error) {
	db := mysql.NewDB()
	var Info models.MaLotteryMember
	db.Model(&models.MaLotteryMember{}).
		Where("id = ? and deleted_at = 0", ID).
		Take(&Info)
	return
}

// Del
func (ls LotteryMemberService) Del(merchantID, ID string) (err error) {

	db := mysql.NewDB()
	db.Model(&models.MaLotteryMember{}).
		Where("id = ? and deleted_at = 0", ID).Delete(&models.MaLotteryMember{})
	return
}

// MemberLog 导出会员记录
func (ls LotteryMemberService) ExportLog() (err error) {

	return
}

// MemberLog 会员日志记录
func (ls LotteryMemberService) MemberLog() (err error) {

	return
}

// 新版开始抽奖，返回当前订单是否抽中 ：： 抽奖需要创单。没有抽中返回谢谢惠顾！
func (ls LotteryMemberService) PartInLottery(
	ActivityID, // 活动ID
	SalesID, // 机器识别码
	OutTradeNo string, //订单号
) (
	res interface{},
	err error,
) {
	db := mysql.NewDB()
	// 1.判断当前活动是否进行中且有效，
	var info models.MaLotteryActivity
	var count int64
	db.Model(&models.MaLotteryActivity{}).
		Where("id = ?", ActivityID).
		Take(&info).
		Count(&count)
	if count == 0 {
		return "", errorx.New("活动不存在", -1)
	}
	// ----- 写入订单：活动ID，是否抽奖 ----
	UpdateData := make(map[string]interface{})
	UpdateData["lottery_activity_id"] = ActivityID
	UpdateData["is_visit_lottery"] = 1
	db.Model(&models.MaOrder{}).
		Where("out_trade_no = ?", OutTradeNo).
		Updates(&UpdateData)

	// 2. 开始抽奖。需要获取当前抽奖活动的奖项有哪些？中奖概率是多少，以及当前机器的奖品库存剩余多少
	// 使用redis的setNx进行排队抽奖
	rdb := redis.NewDB()
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
	defer cancel()
	for {
		success, _ := rdb.SetNX(ctx, define.RedisLotteryLock+ActivityID, 1, time.Second*3).Result()
		time.Sleep(time.Millisecond * 10)
		if success {

			// 调用抽奖逻辑

			res, err = ls.StartLottery(
				ActivityID,
				SalesID,
				OutTradeNo,
			)

			// 结束
			break
		}
	}
	defer rdb.Del(ctx, define.RedisLotteryLock+ActivityID)
	return
}

type PrizeInfoStruct struct {
	PrizeID        string `json:"prize_id"`
	PrizeName      string `json:"prize_name"`
	RuleType       int64  `json:"rule_type"`
	GoodsID        string `json:"goods_id"`
	SalesID        string `json:"sales_id"`
	ContainerNum   int    `json:"container_num"`
	ContainerFloor int    `json:"container_floor"`
	OutTradeNo     string `json:"out_trade_no"`
	OldOutTradeNo  string `json:"old_out_trade_no"`
}

// 开始抽奖，使用redis的setnx防止高并发
func (ls LotteryMemberService) StartLottery(
	ActivityID string,
	SalesID string,
	OutTradeNo string,
) (
	PrizeInfo PrizeInfoStruct, // 返回的中奖信息，谢谢惠顾也是一个奖项。
	err error, // 可能发生的错误信息
) {
	// 抽奖前，查询是否达到了【奖项设置的最大可中奖人数】
	// ------  多个奖项加起来是100%  ------
	// 计算方法 ： 100% - 一等奖 - 二等奖 -三等奖 = 谢谢惠顾
	// 1.查询活动的奖项有哪些？并计算各种奖项的中奖概率
	var info = []models.MaLotteryPrizeRule{}
	db := mysql.NewDB()
	db.Model(&models.MaLotteryPrizeRule{}).
		Where("lottery_activity_id = ?", ActivityID).
		Find(&info)
	if len(info) == 0 {
		// 奖项不存在，返回谢谢惠顾
		return
	}

	// 2.注：查询当前机器的奖品库存 ----- 或者 中奖之后查询。如果库存没有了，则直接返回谢谢惠顾 【2种方案二选一】
	// 3.计算各种奖项的中奖概率, 把概率和对应的奖项放入map
	var myPrizeMap = make(map[string]float64)
	var myPrizeIDMap = make(map[string]string)
	var myPrizeRuleTypeMap = make(map[string]int64)
	var myPrizeRuleCountMap = make(map[string]int64)
	var myNotPrizeInfo PrizeInfoStruct
	for _, v := range info {
		myPrizeMap[v.Name] = v.WinOdds / 100
		myPrizeIDMap[v.Name] = v.ID
		myPrizeRuleTypeMap[v.Name] = v.RuleType
		myPrizeRuleCountMap[v.Name] = v.Total // 每个奖项最大可中奖人数
		// 定义(备用奖项)：因为奖品已经抽完，或者奖项不存在,订单创建失败等情况的返回的示例。
		if v.RuleType == 2 {
			myNotPrizeInfo.PrizeID = v.ID
			myNotPrizeInfo.PrizeName = v.Name
			myNotPrizeInfo.SalesID = SalesID
			myNotPrizeInfo.RuleType = 2
		}
	}

	// 4.开始抽奖 () 到底是返回奖项ID？还是返回奖项名称？
	prizeName := ls.DrawPrize(
		myPrizeMap, // 把奖项和中奖概率传入
	)

	// if prizeName != "谢谢惠顾" {

	// 判断当前活动的当前奖项，的已中奖名额，是否超标？ --- 比如奖项（一等奖）设有最大10个名额，
	var prizeRuleIDCount int64
	db.Model(&models.MaLotteryOrder{}).
		Where("activity_id = ?", ActivityID).
		Where("prize_rule_id = ?", myPrizeIDMap[prizeName]). // 查询中奖订单表，当前奖项的中奖订单总数
		Count(&prizeRuleIDCount)
	if prizeRuleIDCount >= myPrizeRuleCountMap[prizeName] {
		// 已经超标，返回谢谢惠顾
		return myNotPrizeInfo, nil
	}
	// 判断所中奖项是否存在？
	if _, ok := myPrizeIDMap[prizeName]; ok {
		// 获取奖项商品
		prizeGoodsIDs, _ := dao.ObjAssociation{}.GetAssociationID(
			context.Background(),
			dal.Q,
			define.AssociationLotteryPrize,
			myPrizeIDMap[prizeName],
			"",
		)
		if len(prizeGoodsIDs) > 0 {
			// 判断当前机器是否有库存（奖品必须有库存才能创单,奖品ID存储在ObjAssoc表里面）
			for _, goodsID := range prizeGoodsIDs {
				var container_num_info models.MaRobotSalesInfo
				db.Model(&models.MaRobotSalesInfo{}).
					Where("sales_id = ?", SalesID).
					Where("goods_id = ?", goodsID).
					Where("container_status = 1"). // 货道状态为正常
					Where("goods_inventory >= 1"). // 剩余库存必须剩余1个。如果奖品库存已经不够，则直接返回谢谢参与
					Take(&container_num_info)
				if container_num_info.GoodsID == goodsID {
					// 如果存在, 马上退出当次循环。说明【抽中奖项中】的【商品】库存足，开始创单，并返回创单信息
					// 【抽中了几等奖，哪个商品(商品ID)，机器识别码、商品ID、货道号、原始订单号】
					//===========  定义生成唯一订单号 ==============
					NewOutTradeNo, _ := helper.UUID{}.String()

					PrizeInfo.PrizeID = myPrizeIDMap[prizeName] // 奖项ID
					PrizeInfo.PrizeName = prizeName
					PrizeInfo.RuleType = myPrizeRuleTypeMap[prizeName] // 获取当前所中奖的奖品类型。用于区分谢谢惠顾
					PrizeInfo.GoodsID = container_num_info.GoodsID
					PrizeInfo.SalesID = SalesID
					PrizeInfo.ContainerNum = container_num_info.ContainerNum
					PrizeInfo.ContainerFloor = container_num_info.ContainerFloor
					PrizeInfo.OldOutTradeNo = OutTradeNo
					PrizeInfo.OutTradeNo = NewOutTradeNo

					// 指定商品及货道号，开始创建奖品订单
					var RobotInfo models.MaRobot
					db.Model(&models.MaRobot{}).Where("sales_id = ? and deleted = 0", SalesID).Take(&RobotInfo)

					// 查询商品信息
					var GoodsInfo models.MaGoodsInfo
					db.Model(&models.MaGoodsInfo{}).Where("goods_id = ? and deleted = 0", container_num_info.GoodsID).Take(&GoodsInfo)

					// 写入抽奖订单表
					var InsertData models.MaLotteryOrder
					childCountData := make(map[string]interface{})
					var slice = []map[string]interface{}{}
					childCountData["ClassID"] = GoodsInfo.ClassID
					childCountData["ContainerNum"] = container_num_info.ContainerNum
					childCountData["GoodsID"] = container_num_info.GoodsID
					childCountData["GoodsName"] = GoodsInfo.GoodsName1
					childCountData["id"] = 0
					childCountData["Univalent"] = GoodsInfo.Price
					slice = append(slice, childCountData)
					newDataByte, _ := json.Marshal(&slice)
					OldGoodsData := common.Order{}.CountDataNewToOld(string(newDataByte))
					oldDataByte, _ := json.Marshal(&OldGoodsData)
					oldDataString := strings.ReplaceAll(string(oldDataByte), `\\u`, `\u`)
					// 子订单号
					InsertData.ChildOutTradeNo = NewOutTradeNo
					InsertData.OutTradeNo = NewOutTradeNo
					InsertData.ID = RobotInfo.MerchantID
					InsertData.MerchantID = RobotInfo.MerchantID
					InsertData.RobotName = RobotInfo.RobotName
					InsertData.Areas1 = RobotInfo.Areas1
					InsertData.Areas2 = RobotInfo.Areas2
					InsertData.Areas3 = RobotInfo.Areas3
					InsertData.Areas4 = RobotInfo.Areas4
					InsertData.Areas5 = RobotInfo.Areas5
					InsertData.SalesID = SalesID
					InsertData.AddTime = time.Now()
					InsertData.PaymentAmount = 0
					InsertData.CountData = oldDataString
					InsertData.OrderStatus = 1
					InsertData.ModifyTime = time.Now()
					InsertData.End = 0
					InsertData.CreatedDate = time.Now()
					InsertData.ActivityID = ActivityID
					InsertData.PrizeRuleID = myPrizeIDMap[prizeName] // 记录中的奖是几等奖。当下一个人再次抽奖时候，可用于校验最大可中奖人数是否超标。
					InsertData.OldOutTradeNo = OutTradeNo
					// 写入抽奖订单表
					err = db.Model(&models.MaLotteryOrder{}).Create(&InsertData).Error
					if err != nil {
						err = errorx.New("订单创建失败", -1)
						return myNotPrizeInfo, err
					}
					break
				} else {
					// 如果不存在，继续下一个奖品（因为一个奖项，可以设置多个同等价值的奖品）
					continue
				}
			}
		}
		// 兜底
		if PrizeInfo.PrizeID == "" {
			return myNotPrizeInfo, nil
		}
	}
	// } else {
	// 	PrizeInfo.PrizeID = myPrizeIDMap[prizeName] // 奖项ID
	// 	PrizeInfo.PrizeName = prizeName
	// 	PrizeInfo.SalesID = SalesID
	// 	PrizeInfo.RuleType = myPrizeRuleTypeMap[prizeName] // 获取当前所中奖的奖品类型。用于区分谢谢惠顾
	// }

	return
}

// 执行抽奖 》 中奖则需要返回中的奖项等级。 prizes 奖项信息map格式
func (ls LotteryMemberService) DrawPrize(prizes map[string]float64) string {

	// 计算总概率（一等奖0.01%+二等奖0.1%+谢谢惠顾98.99%）
	totalProb := 0.0
	for _, prob := range prizes {
		totalProb += prob
	}

	if totalProb < 1 {
		totalProb = 1
	}

	// 生成一个随机数
	seed := rand.NewSource(time.Now().UnixNano())
	randomNum := rand.New(seed).Float64()

	// 根据随机数，确定获奖者
	accumulatedProb := 0.0

	// prize 奖项名称
	// prob 中奖概率
	for prize, prob := range prizes {
		accumulatedProb += prob
		if randomNum <= accumulatedProb/totalProb {
			return prize // 已中奖，需要返回中奖信息
		}
	}
	// 如果没有匹配到奖项，返回一个默认的奖项
	return "谢谢惠顾"
}

/* // DrawPrizeInt 计算整数的抽奖
func (ls LotteryMemberService) DrawPrizeInt(prizes map[string]int) string {
	// 计算总概率
	totalProb := 0
	for _, prob := range prizes {
		totalProb += prob
	}
	// 生成一个随机数
	rand.NewSource(time.Now().UnixNano())
	randomNum := rand.Intn(totalProb)
	// 根据随机数确定获奖者
	for prize, prob := range prizes {
		if randomNum < prob {
			return prize
		}
		randomNum -= prob
	}
	// 如果没有匹配到奖项，返回一个默认的奖项
	return "未中奖"
}

// DrawPrizeFloat 计算小数的抽奖
func DrawPrizeFloat(prizes map[string]float64) string {
	prizes = map[string]float64{
		"一等奖":  0.01,
		"二等奖":  0.05,
		"三等奖":  0.1,
		"谢谢参与": 0.84,
	}
	// 计算总概率
	totalProb := 0.0
	for _, prob := range prizes {
		totalProb += prob
	}
	// 生成一个随机数
	rand.NewSource(time.Now().UnixNano())
	randomNum := rand.Float64()
	// 根据随机数确定获奖者
	accumulatedProb := 0.0
	for prize, prob := range prizes {
		accumulatedProb += prob / totalProb
		if randomNum <= accumulatedProb {
			return prize
		}
	}
	// 如果没有匹配到奖项，返回一个默认的奖项
	return "未中奖"
} */

// 【老版本锦鲤活动使用】 开始抽奖
func (ls LotteryMemberService) GetLotteryCode(
	ActivityID,
	SalesID,
	Phone string,
	OutTradeNo string,
) (
	raffle_code string,
	err error,
) {

	db := mysql.NewDB()
	// 1.判断当前活动是否进行中且有效，
	var info models.MaLotteryActivity
	var count int64
	db.Model(&models.MaLotteryActivity{}).
		Where("id = ?", ActivityID).
		Take(&info).
		Count(&count)
	// 如果活动不存在
	if count == 0 {
		return "", errorx.New("获取锦鲤号码失败", -1)
	}
	var memberinfo models.MaLotteryMember
	db.Model(&models.MaLotteryMember{}).
		Where("phone = ?", Phone).
		Take(&memberinfo)

	// 判断该活动（对用户）是否有参与次数限制。否则买一单就获得一个【锦鲤号码】
	// 单日限制
	// if info.DaliyLotteryTimes != -1 {
	if info.DaliyLotteryTimes > 0 {
		var userTodayCount int64
		// 获取当前用户, 今日总参与次数
		startTime := carbon.Now().StartOfDay().ToDateTimeString()
		endTime := carbon.Now().ToDateTimeString()
		db.Model(&models.MaLotteryMemberActiveLog{}).
			Where("type = 2"). // 参与抽奖
			Where("lottery_activity_id = ?", ActivityID).
			Where("created_at > ?", startTime). // 大于当日开始时间
			Where("created_at < ?", endTime).   // xiao于当日jieshu时间
			Count(&userTodayCount)

		// 2.和总参与次数做比较
		if int(userTodayCount) > info.DaliyLotteryTimes {
			return "", errorx.New("超过单日参与次数", -1)
		}
	}
	// 总的次数限制
	// if info.TotalLotteryTimes != -1 {
	if info.TotalLotteryTimes > 0 {
		var userTotalCount int64
		// 获取当前用户, 总参与次数
		db.Model(&models.MaLotteryMemberActiveLog{}).
			Where("type = 2"). // 参与抽奖
			Where("lottery_activity_id = ?", ActivityID).
			Count(&userTotalCount)
		// 1. 和当日的作比较
		if int(userTotalCount) > info.TotalLotteryTimes {
			return "", errorx.New("超过总的参与次数", -1)
		}
	}

	// 生成兑奖码.保证每个码都是唯一的，一个订单对应一个码。
	raffle_code, err = ls.generateUnique6DigitNumber(
		Phone,
		ActivityID,
		SalesID,
		memberinfo.ID,
		OutTradeNo,
	)
	// 发送短信通知用户，并派发兑奖码
	// 选择发送模版，开始发送短信
	templateCode := config.Config.SMSTemplateCode2
	rds := redis.NewDB()
	content := make(map[string]interface{})
	content["redemption_code"] = raffle_code // 兑奖码
	if info.RedemptionStartTime > 0 && info.RedemptionEndTime > 0 {

		// 把时间戳转化为日期格式
		redemptionStartTime := carbon.CreateFromTimestamp(int64(info.RedemptionStartTime)).ToDateString()
		redemptionEndTime := carbon.CreateFromTimestamp(int64(info.RedemptionEndTime)).ToDateString()

		content["start_time"] = redemptionStartTime //"2023.11.20"     // 开始时间
		content["end_time"] = redemptionEndTime     //"2023.11.20"     // 结束时间
	} else if info.RedemptionStartWeek != "" {
		weekNum := strings.Split(info.RedemptionStartWeek, ",")
		var startWeek string
		if len(weekNum) > 0 {
			for _, v := range weekNum {
				switch v {
				case "1":
					startWeek += "星期一、"
				case "2":
					startWeek += "星期二、"
				case "3":
					startWeek += "星期三、"
				case "4":
					startWeek += "星期四、"
				case "5":
					startWeek += "星期五、"
				case "6":
					startWeek += "星期六、"
				case "7":
					startWeek += "星期日、"
				}
			}
		}
		if startWeek != "" {
			content["start_time"] = strings.Trim(startWeek, "、") //"2023.11.20"     // 转化为星期格式
		}
	}

	helper.SendSMSTxt(rds, Phone, content, templateCode)
	return
}

func (ls LotteryMemberService) generateUnique6DigitNumber(
	Phone string,
	ActivityID string,
	SalesID string,
	MemberID string,
	OutTradeNo string,
) (
	randomString string,
	err error,
) {
	// 确保生成的数字唯一
	for {
		randomString = ls.GenCode()
		// 在这里，您需要实现一个函数来检查数字是否已存在，比如检查数据库或其他存储介质
		// 检查函数调用 checkIfExists(randomString)
		// 如果数字不存在，则返回生成的数字
		var codeCount int64
		mysql.NewDB().Model(&models.MaLotteryCode{}).
			Where("code = ?", randomString). // 参与抽奖
			Count(&codeCount)
		if codeCount > 0 {
			continue
		} else {
			// 锦鲤号码表
			var insertCode models.MaLotteryCode
			insertCode.Code = randomString
			insertCode.Phone = Phone
			insertCode.ActivityID = ActivityID
			insertCode.MemberID = MemberID
			insertCode.SalesID = SalesID
			err = mysql.NewDB().Model(&models.MaLotteryCode{}).
				Create(&insertCode).Error
			if err != nil {
				// logx
				logx.Error(context.Background(), "获取锦鲤号码失败")
				return "", errorx.New("获取锦鲤号码失败", -1)
			} else {
				// 写入会员参与抽奖日志
				err = LotteryMemberActivityLogService{}.Add(
					2,            // 参与抽奖
					SalesID,      // 机器识别码（用于查找注册用户来源）
					ActivityID,   // 活动id
					MemberID,     // 用户id
					OutTradeNo,   // 订单号
					Phone,        // 手机号
					randomString, // 锦鲤号码
				)
				if err == nil {
					// 用户抽奖次数+1
					// mysql.NewDB().Model(&models.MaLotteryMember{}).Where("id = ?", MemberID).UpdateColumn(
					// 	"lottery_times",
					// 	gorm.Expr("lottery_timses + 1"),
					// )
					// 这个更新会更新时间戳 updated_at
					mysql.NewDB().Model(&models.MaLotteryMember{}).Where("id = ?", MemberID).Update(
						"lottery_times",
						gorm.Expr("lottery_times + 1"),
					)

				}
			}
		}
		return
	}
}

func (ls LotteryMemberService) GenCode() string {
	// 设置随机种子
	rd := rand.New(rand.NewSource(time.Now().Unix()))
	// 生成6位随机数字
	randomNumber := rd.Intn(999999)
	// 将随机数字转换为字符串
	randomString := fmt.Sprintf("%06s", strconv.FormatInt(int64(randomNumber), 10))
	return randomString
}

// Add 添加/编辑 【会员】
func (ls LotteryMemberService) Add(
	merchantID,
	ID,
	Phone,
	SalesID,
	OutTradeNo,
	ActivityID string,
) (err error) {

	db := mysql.NewDB()

	// 新增
	if ID == "" {
		var InsertData models.MaLotteryMember
		// 3.添加会员奖项设置，写入奖项设置及奖品数据
		UUID, _ := helper.UUID{}.String()
		InsertData.ID = UUID
		InsertData.Phone = Phone
		InsertData.ActivityID = ActivityID
		InsertData.SalesID = SalesID
		InsertData.OutTradeNo = OutTradeNo

		// 执行写入
		err = db.Model(&models.MaLotteryMember{}).Create(&InsertData).Error
		if err != nil {
			err = errorx.New("新增失败！", -1)
			return
		} else {
			// 写入会员 注册日志
			err = LotteryMemberActivityLogService{}.Add(
				1,             // 注册
				SalesID,       // 用于查找当前注册的用户的来源
				ActivityID,    // 活动ID
				InsertData.ID, // 用户id
				OutTradeNo,    // 订单号
				Phone,         // 手机号
				"",
			)
		}

	} else {

		// 执行修改
		var LotteryCount int64
		var Info models.MaLotteryMember
		// 1 获取会员数据
		db.Model(&models.MaLotteryMember{}).Where("id = ? and deleted_at = 0", ID).Take(&Info).Count(&LotteryCount)
		// 执行更新
		// UpdateData := make(map[string]interface{})
		var UpdateData = models.MaLotteryMember{} // 结构体更新，会把0忽略
		UpdateData.Phone = Phone
		// 执行更新会员表
		db.Model(&models.MaLotteryMember{}).
			Where("id = ?", ID).
			Updates(&UpdateData)
	}
	return
}
